// 游戏常量
const GRID_SIZE = 20;
const CANVAS_WIDTH = 400;
const CANVAS_HEIGHT = 400;
const CELL_SIZE = CANVAS_WIDTH / GRID_SIZE;
const INITIAL_SPEED = 150; // 初始速度（毫秒）
const SPEED_INCREASE = 5; // 每次加速减少的毫秒数
const MIN_SPEED = 50; // 最小速度（毫秒）

// 游戏状态
let snake = [];
let food = {};
let direction = '';
let nextDirection = '';
let score = 0;
let gameInterval = null;
let gameSpeed = INITIAL_SPEED;
let isGameRunning = false;
let isPaused = false;

// 获取DOM元素
const canvas = document.getElementById('gameCanvas');
const ctx = canvas.getContext('2d');
const scoreElement = document.getElementById('score');
const startBtn = document.getElementById('startBtn');
const pauseBtn = document.getElementById('pauseBtn');
const restartBtn = document.getElementById('restartBtn');

// 初始化游戏
function initGame() {
    // 初始化蛇（从中间开始）
    const center = Math.floor(GRID_SIZE / 2);
    snake = [
        { x: center, y: center },
        { x: center - 1, y: center },
        { x: center - 2, y: center }
    ];
    
    direction = 'right';
    nextDirection = 'right';
    score = 0;
    gameSpeed = INITIAL_SPEED;
    isGameRunning = false;
    isPaused = false;
    
    // 生成初始食物
    generateFood();
    
    // 更新分数显示
    updateScore();
    
    // 绘制初始游戏状态
    drawGame();
}

// 生成食物
function generateFood() {
    // 确保食物不会出现在蛇身上
    let validPosition = false;
    let newFood;
    
    while (!validPosition) {
        newFood = {
            x: Math.floor(Math.random() * GRID_SIZE),
            y: Math.floor(Math.random() * GRID_SIZE)
        };
        
        // 检查食物是否在蛇身上
        validPosition = !snake.some(segment => segment.x === newFood.x && segment.y === newFood.y);
    }
    
    food = newFood;
}

// 更新游戏状态
function updateGame() {
    if (!isGameRunning || isPaused) return;
    
    // 更新方向
    direction = nextDirection;
    
    // 获取蛇头位置
    const head = { ...snake[0] };
    
    // 根据方向移动蛇头
    switch (direction) {
        case 'up':
            head.y--;
            break;
        case 'down':
            head.y++;
            break;
        case 'left':
            head.x--;
            break;
        case 'right':
            head.x++;
            break;
    }
    
    // 检查碰撞（墙壁或自身）
    if (checkCollision(head)) {
        gameOver();
        return;
    }
    
    // 将新头添加到蛇身
    snake.unshift(head);
    
    // 检查是否吃到食物
    if (head.x === food.x && head.y === food.y) {
        // 增加分数
        score += 10;
        updateScore();
        
        // 生成新食物
        generateFood();
        
        // 增加游戏速度（如果还没达到最小速度）
        if (gameSpeed > MIN_SPEED) {
            gameSpeed = Math.max(MIN_SPEED, gameSpeed - SPEED_INCREASE);
            restartGameLoop();
        }
    } else {
        // 如果没吃到食物，移除尾部
        snake.pop();
    }
    
    // 绘制游戏
    drawGame();
}

// 检查碰撞
function checkCollision(head) {
    // 检查墙壁碰撞
    if (head.x < 0 || head.x >= GRID_SIZE || head.y < 0 || head.y >= GRID_SIZE) {
        return true;
    }
    
    // 检查自身碰撞（从第三个段开始检查，因为头不可能碰到前两个段）
    for (let i = 2; i < snake.length; i++) {
        if (head.x === snake[i].x && head.y === snake[i].y) {
            return true;
        }
    }
    
    return false;
}

// 绘制游戏
function drawGame() {
    // 清空画布
    ctx.clearRect(0, 0, CANVAS_WIDTH, CANVAS_HEIGHT);
    
    // 绘制网格（可选）
    drawGrid();
    
    // 绘制蛇
    drawSnake();
    
    // 绘制食物
    drawFood();
    
    // 如果游戏暂停，显示暂停信息
    if (isPaused) {
        drawPauseScreen();
    }
}

// 绘制网格
function drawGrid() {
    ctx.strokeStyle = '#333';
    ctx.lineWidth = 0.5;
    
    // 绘制垂直线
    for (let i = 0; i <= GRID_SIZE; i++) {
        ctx.beginPath();
        ctx.moveTo(i * CELL_SIZE, 0);
        ctx.lineTo(i * CELL_SIZE, CANVAS_HEIGHT);
        ctx.stroke();
    }
    
    // 绘制水平线
    for (let i = 0; i <= GRID_SIZE; i++) {
        ctx.beginPath();
        ctx.moveTo(0, i * CELL_SIZE);
        ctx.lineTo(CANVAS_WIDTH, i * CELL_SIZE);
        ctx.stroke();
    }
}

// 绘制蛇
function drawSnake() {
    snake.forEach((segment, index) => {
        // 设置颜色（头和身体不同颜色）
        if (index === 0) {
            ctx.fillStyle = '#2ecc71'; // 蛇头绿色
        } else {
            ctx.fillStyle = '#27ae60'; // 蛇身深绿色
        }
        
        // 绘制蛇段
        ctx.fillRect(
            segment.x * CELL_SIZE + 1,
            segment.y * CELL_SIZE + 1,
            CELL_SIZE - 2,
            CELL_SIZE - 2
        );
        
        // 为蛇头绘制眼睛
        if (index === 0) {
            drawEyes(segment);
        }
    });
}

// 绘制蛇眼
function drawEyes(head) {
    ctx.fillStyle = 'white';
    const eyeSize = CELL_SIZE / 5;
    const eyeOffset = CELL_SIZE / 4;
    
    switch (direction) {
        case 'up':
            ctx.fillRect(head.x * CELL_SIZE + eyeOffset, head.y * CELL_SIZE + eyeOffset, eyeSize, eyeSize);
            ctx.fillRect(head.x * CELL_SIZE + CELL_SIZE - eyeOffset - eyeSize, head.y * CELL_SIZE + eyeOffset, eyeSize, eyeSize);
            break;
        case 'down':
            ctx.fillRect(head.x * CELL_SIZE + eyeOffset, head.y * CELL_SIZE + CELL_SIZE - eyeOffset - eyeSize, eyeSize, eyeSize);
            ctx.fillRect(head.x * CELL_SIZE + CELL_SIZE - eyeOffset - eyeSize, head.y * CELL_SIZE + CELL_SIZE - eyeOffset - eyeSize, eyeSize, eyeSize);
            break;
        case 'left':
            ctx.fillRect(head.x * CELL_SIZE + eyeOffset, head.y * CELL_SIZE + eyeOffset, eyeSize, eyeSize);
            ctx.fillRect(head.x * CELL_SIZE + eyeOffset, head.y * CELL_SIZE + CELL_SIZE - eyeOffset - eyeSize, eyeSize, eyeSize);
            break;
        case 'right':
            ctx.fillRect(head.x * CELL_SIZE + CELL_SIZE - eyeOffset - eyeSize, head.y * CELL_SIZE + eyeOffset, eyeSize, eyeSize);
            ctx.fillRect(head.x * CELL_SIZE + CELL_SIZE - eyeOffset - eyeSize, head.y * CELL_SIZE + CELL_SIZE - eyeOffset - eyeSize, eyeSize, eyeSize);
            break;
    }
}

// 绘制食物
function drawFood() {
    ctx.fillStyle = '#e74c3c'; // 食物红色
    ctx.beginPath();
    ctx.arc(
        food.x * CELL_SIZE + CELL_SIZE / 2,
        food.y * CELL_SIZE + CELL_SIZE / 2,
        CELL_SIZE / 2 - 2,
        0,
        Math.PI * 2
    );
    ctx.fill();
}

// 绘制暂停屏幕
function drawPauseScreen() {
    ctx.fillStyle = 'rgba(0, 0, 0, 0.5)';
    ctx.fillRect(0, 0, CANVAS_WIDTH, CANVAS_HEIGHT);
    
    ctx.fillStyle = 'white';
    ctx.font = '30px Arial';
    ctx.textAlign = 'center';
    ctx.fillText('游戏暂停', CANVAS_WIDTH / 2, CANVAS_HEIGHT / 2);
    
    ctx.font = '16px Arial';
    ctx.fillText('按空格键继续', CANVAS_WIDTH / 2, CANVAS_HEIGHT / 2 + 40);
}

// 更新分数
function updateScore() {
    scoreElement.textContent = score;
}

// 开始游戏
function startGame() {
    if (!isGameRunning) {
        isGameRunning = true;
        isPaused = false;
        startGameLoop();
        startBtn.textContent = '游戏中';
        startBtn.disabled = true;
    }
}

// 暂停游戏
function pauseGame() {
    if (isGameRunning) {
        isPaused = !isPaused;
        pauseBtn.textContent = isPaused ? '继续' : '暂停';
    }
}

// 重新开始游戏
function restartGame() {
    // 清除游戏循环
    if (gameInterval) {
        clearInterval(gameInterval);
    }
    
    // 重新初始化游戏
    initGame();
    
    // 重置按钮状态
    startBtn.textContent = '开始游戏';
    startBtn.disabled = false;
    pauseBtn.textContent = '暂停';
}

// 游戏结束
function gameOver() {
    isGameRunning = false;
    
    // 清除游戏循环
    if (gameInterval) {
        clearInterval(gameInterval);
    }
    
    // 显示游戏结束信息
    ctx.fillStyle = 'rgba(0, 0, 0, 0.7)';
    ctx.fillRect(0, 0, CANVAS_WIDTH, CANVAS_HEIGHT);
    
    ctx.fillStyle = 'white';
    ctx.font = '30px Arial';
    ctx.textAlign = 'center';
    ctx.fillText('游戏结束', CANVAS_WIDTH / 2, CANVAS_HEIGHT / 2 - 30);
    
    ctx.font = '20px Arial';
    ctx.fillText(`最终分数: ${score}`, CANVAS_WIDTH / 2, CANVAS_HEIGHT / 2 + 10);
    
    ctx.font = '16px Arial';
    ctx.fillText('点击"重新开始"按钮再玩一次', CANVAS_WIDTH / 2, CANVAS_HEIGHT / 2 + 50);
    
    // 重置按钮状态
    startBtn.textContent = '开始游戏';
    startBtn.disabled = false;
}

// 开始游戏循环
function startGameLoop() {
    if (gameInterval) {
        clearInterval(gameInterval);
    }
    gameInterval = setInterval(updateGame, gameSpeed);
}

// 重新启动游戏循环（用于速度调整）
function restartGameLoop() {
    if (isGameRunning) {
        startGameLoop();
    }
}

// 处理键盘输入
function handleKeyPress(event) {
    // 防止页面滚动
    if ([37, 38, 39, 40, 32].includes(event.keyCode)) {
        event.preventDefault();
    }
    
    switch (event.keyCode) {
        case 38: // 上箭头
            // 不能直接向上移动（如果当前方向是下）
            if (direction !== 'down') {
                nextDirection = 'up';
            }
            break;
        case 40: // 下箭头
            // 不能直接向下移动（如果当前方向是上）
            if (direction !== 'up') {
                nextDirection = 'down';
            }
            break;
        case 37: // 左箭头
            // 不能直接向左移动（如果当前方向是右）
            if (direction !== 'right') {
                nextDirection = 'left';
            }
            break;
        case 39: // 右箭头
            // 不能直接向右移动（如果当前方向是左）
            if (direction !== 'left') {
                nextDirection = 'right';
            }
            break;
        case 32: // 空格键
            if (isGameRunning) {
                pauseGame();
            } else if (!isGameRunning && score > 0) {
                startGame();
            }
            break;
    }
}

// 添加事件监听器
startBtn.addEventListener('click', startGame);
pauseBtn.addEventListener('click', pauseGame);
restartBtn.addEventListener('click', restartGame);
window.addEventListener('keydown', handleKeyPress);

// 初始化游戏
initGame();